package com.sheng.leetcode.year2023.month06.day16;

import org.junit.Test;

import java.util.Arrays;

/**
 * @author liusheng
 * @date 2023/06/16
 * <p>
 * 1494. 并行课程 II<p>
 * <p>
 * 给你一个整数 n 表示某所大学里课程的数目，编号为 1 到 n ，数组 relations 中，<p>
 * relations[i] = [xi, yi]  表示一个先修课的关系，也就是课程 xi 必须在课程 yi 之前上。同时你还有一个整数 k 。<p>
 * 在一个学期中，你 最多 可以同时上 k 门课，前提是这些课的先修课在之前的学期里已经上过了。<p>
 * 请你返回上完所有课最少需要多少个学期。题目保证一定存在一种上完所有课的方式。<p>
 * <p>
 * 示例 1：<p>
 * 输入：n = 4, relations = [[2,1],[3,1],[1,4]], k = 2<p>
 * 输出：3<p>
 * 解释：上图展示了题目输入的图。在第一个学期中，我们可以上课程 2 和课程 3 。然后第二个学期上课程 1 ，第三个学期上课程 4 。<p>
 * <p>
 * 示例 2：<p>
 * 输入：n = 5, relations = [[2,1],[3,1],[4,1],[1,5]], k = 2<p>
 * 输出：4<p>
 * 解释：上图展示了题目输入的图。一个最优方案是：第一学期上课程 2 和 3，第二学期上课程 4 ，第三学期上课程 1 ，第四学期上课程 5 。<p>
 * <p>
 * 示例 3：<p>
 * 输入：n = 11, relations = [], k = 2<p>
 * 输出：6<p>
 * <p>
 * 提示：<p>
 * 1 <= n <= 15<p>
 * 1 <= k <= n<p>
 * 0 <= relations.length <= n * (n-1) / 2<p>
 * relations[i].length == 2<p>
 * 1 <= xi, yi <= n<p>
 * xi != yi<p>
 * 所有先修关系都是不同的，也就是说 relations[i] != relations[j] 。<p>
 * 题目输入的图是个有向无环图。<p>
 * <p>
 * 来源：力扣（LeetCode）<p>
 * 链接：<a href="https://leetcode.cn/problems/parallel-courses-ii">1494. 并行课程 II</a><p>
 * 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。<p>
 */
public class LeetCode1494 {

    @Test
    public void test01() {
        int n = 4, k = 2;
        int[][] relations = {{2, 1}, {3, 1}, {1, 4}};
//        int n = 5, k = 2;
//        int[][] relations = {{2, 1}, {3, 1}, {4, 1}, {1, 5}};
//        int n = 11, k = 2;
//        int[][] relations = {};
        System.out.println(new Solution().minNumberOfSemesters(n, relations, k));
    }
}

class Solution {
    public int minNumberOfSemesters(int n, int[][] relations, int k) {
        // pre[i] 表示课程 i 需要的前置课程，例如课程 1 为前置课程，则将第 0 位 置为 1
        int[] pre = new int[n];
        int all = 1 << n;
        // 表示到达修课情况为 i 的状态需要的总轮数 dp[i]
        int[] dp = new int[all];
        Arrays.fill(dp, n);
        dp[0] = 0;
        for (int[] relation : relations) {
            pre[relation[1] - 1] |= 1 << (relation[0] - 1);
        }
        for (int state = 0; state < all; state++) {
            // 目前修课状态是 state，next 表示接下来能修哪些课
            int next = 0;
            for (int i = 0; i < n; i++) {
                // 如果一个课程 i 的所有前置课程 pre[i] 都已经修过了：(state & pre[i]) == pre[i]
                // 那么就加入这门课程作为接下来要修的课程：next |= 1 << i;
                if ((state & pre[i]) == pre[i]) {
                    next |= 1 << i;
                }
            }
            // 已经修过的课程不能重复修，state 为已经修过的课程，~state 为没有修过的课程，取 next 与 ~state 的交集
            next &= ~state;
            // 枚举接下来可以修的课程的所有可能
            for (int sub = next; sub > 0; sub = (sub - 1) & next) {
                if (Integer.bitCount(sub) <= k) {
                    // 算上这轮修的课程 sub，一共修了课程 state | sub
                    int nextTotal = state | sub;
                    dp[nextTotal] = Math.min(dp[nextTotal], dp[state] + 1);
                }
            }
        }
        return dp[all - 1];
    }
}
